#include "bsp_oled.h"
#include "bsp_delay.h"
#include "string.h"
#include "oled_font.h"
#include "bsp_board.h"

u8 oled_gram[144][8];


/* 初始化spi2引脚 */
static void oled_gpio_config()
{
	gpio_init_type gpio_initstructure;
	/* 初始化默认配置 */
	gpio_default_para_init(&gpio_initstructure);

	/* cs */
	crm_periph_clock_enable(OLED_SPI_CS_CRM, TRUE);
	gpio_initstructure.gpio_out_type       	= GPIO_OUTPUT_PUSH_PULL;
	gpio_initstructure.gpio_drive_strength 	= GPIO_DRIVE_STRENGTH_STRONGER;
	gpio_initstructure.gpio_pull           	= GPIO_PULL_UP;
	gpio_initstructure.gpio_mode           	= GPIO_MODE_MUX;
	gpio_initstructure.gpio_pins			= OLED_SPI_CS_PIN;
	gpio_init(OLED_SPI_CS_GPIO, &gpio_initstructure);
	gpio_pin_mux_config(OLED_SPI_CS_GPIO, OLED_SPI_CS_SOURCE, OLED_SPI_CS_MUX);
	/* sck */
	crm_periph_clock_enable(OLED_SPI_SCK_CRM, TRUE);
	gpio_initstructure.gpio_out_type       	= GPIO_OUTPUT_PUSH_PULL;
	gpio_initstructure.gpio_drive_strength 	= GPIO_DRIVE_STRENGTH_STRONGER;
	gpio_initstructure.gpio_pull           	= GPIO_PULL_DOWN;
	gpio_initstructure.gpio_mode           	= GPIO_MODE_MUX;
	gpio_initstructure.gpio_pins			= OLED_SPI_SCK_PIN;
	gpio_init(OLED_SPI_SCK_GPIO, &gpio_initstructure);
	gpio_pin_mux_config(OLED_SPI_SCK_GPIO, OLED_SPI_SCK_SOURCE, OLED_SPI_SCK_MUX);
	/* miso */
//	crm_periph_clock_enable(OLED_SPI_MISO_CRM, TRUE);
//	gpio_initstructure.gpio_out_type       	= GPIO_OUTPUT_PUSH_PULL;
//	gpio_initstructure.gpio_drive_strength 	= GPIO_DRIVE_STRENGTH_STRONGER;
//	gpio_initstructure.gpio_pull           	= GPIO_PULL_UP;
//	gpio_initstructure.gpio_mode           	= GPIO_MODE_MUX;
//	gpio_initstructure.gpio_pins			= OLED_SPI_MISO_PIN;
//	gpio_init(OLED_SPI_MISO_GPIO, &gpio_initstructure);
//	gpio_pin_mux_config(OLED_SPI_MISO_GPIO, OLED_SPI_MISO_SOURCE, OLED_SPI_MISO_MUX);
	/* mosi */
	crm_periph_clock_enable(OLED_SPI_MOSI_CRM, TRUE);
	gpio_initstructure.gpio_out_type       	= GPIO_OUTPUT_PUSH_PULL;
	gpio_initstructure.gpio_drive_strength 	= GPIO_DRIVE_STRENGTH_STRONGER;
	gpio_initstructure.gpio_pull           	= GPIO_PULL_UP;
	gpio_initstructure.gpio_mode           	= GPIO_MODE_MUX;
	gpio_initstructure.gpio_pins			= OLED_SPI_MOSI_PIN;
	gpio_init(OLED_SPI_MOSI_GPIO, &gpio_initstructure);
	gpio_pin_mux_config(OLED_SPI_MOSI_GPIO, OLED_SPI_MOSI_SOURCE, OLED_SPI_MOSI_MUX);
	/* dc */
	crm_periph_clock_enable(OLED_SPI_DC_CRM_CLK, TRUE);
	gpio_default_para_init(&gpio_initstructure);	
	gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
	gpio_initstructure.gpio_out_type  = GPIO_OUTPUT_PUSH_PULL;
	gpio_initstructure.gpio_mode = GPIO_MODE_OUTPUT;
	gpio_initstructure.gpio_pins = OLED_SPI_DC_PIN;
	gpio_initstructure.gpio_pull = GPIO_PULL_NONE;
	gpio_init(OLED_SPI_DC_PORT, &gpio_initstructure);
	gpio_bits_write(OLED_SPI_DC_PORT, OLED_SPI_DC_PIN, FALSE);
	/* res */
	crm_periph_clock_enable(OLED_SPI_RES_CRM_CLK, TRUE);
	gpio_default_para_init(&gpio_initstructure);	
	gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
	gpio_initstructure.gpio_out_type  = GPIO_OUTPUT_PUSH_PULL;
	gpio_initstructure.gpio_mode = GPIO_MODE_OUTPUT;
	gpio_initstructure.gpio_pins = OLED_SPI_RES_PIN;
	gpio_initstructure.gpio_pull = GPIO_PULL_NONE;
	gpio_init(OLED_SPI_RES_PORT, &gpio_initstructure);
	gpio_bits_write(OLED_SPI_RES_PORT, OLED_SPI_RES_PIN, FALSE); 
}
/* 初始化oled使用的spi */
static void oled_spi_config(void)
{
	spi_init_type spi_init_struct;

	/* 使能spi时钟 */
	crm_periph_clock_enable(OLED_SPI_CRM_CLK, TRUE);

	/* 初始化默认配置 */
	spi_default_para_init(&spi_init_struct);

	/* 配置spi */
	spi_init_struct.transmission_mode = SPI_TRANSMIT_HALF_DUPLEX_TX;	/*!< 双线单向全双工模式 */
	spi_init_struct.master_slave_mode = SPI_MODE_MASTER;			/*!< SPI模式主机 */
	spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_32;			/*!< SPI时钟分频 */
	spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_MSB;		/*!< SPI帧格式高字节在前 */
	spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;					/*!< SPI帧数据格式8-bit */
	spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;		/*!< SPI时钟空闲时高电平 */
	spi_init_struct.clock_phase = SPI_CLOCK_PHASE_1EDGE;			/*!< SPI帧格式是从第一时钟沿开始 */
	spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;		/*!< SPI软件使能 */
	spi_init(OLED_SPI_ID, &spi_init_struct);

	/* 中断配置 */
//	nvic_irq_enable(OLED_SPI_IRQn, 4, 0);
//	spi_i2s_interrupt_enable(OLED_SPI_ID, SPI_I2S_TDBE_INT, TRUE);

	/* 使能TI模式 */
//	spi_ti_mode_enable(OLED_SPI_ID, TRUE);

	/* DMA配置 */
//	spi_i2s_dma_transmitter_enable(OLED_SPI_ID, TRUE);
//	spi_i2s_dma_receiver_enable(OLED_SPI_ID, TRUE);
	/* 使能SPI */
	spi_enable(OLED_SPI_ID, TRUE);
}
/* spi2 dma发送数据 */
void oled_spi_send_data(uint8_t *buff, uint16_t len)
{
	dma_init_type dma_init_struct;

	/* 使能DMA时钟 */
	crm_periph_clock_enable(OLED_SPI_DMA_CRM_CLK, TRUE);

	/* 复位当前使用DMA通道 */
	dma_reset(OLED_SPI_DMA_TX_CHANNEL);

	/* 配置DMA矩阵 */
	dmamux_init(OLED_SPI_DMA_TX_MUX, OLED_SPI_DMA_TX_MUX_ID);

	/* 使能DMA */
	dmamux_enable(OLED_SPI_DMA_ID, TRUE);

	/* 配置DMA通道 */
	dma_default_para_init(&dma_init_struct);
	dma_init_struct.buffer_size = len;											/*!< DMA传输长度 */
	dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_BYTE;				/*!< DMA传输数据位宽 */
	dma_init_struct.memory_inc_enable = TRUE;									/*!< DMA地址递增 */
	dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_BYTE;		/*!< DMA外设数据位宽 */
	dma_init_struct.peripheral_inc_enable = FALSE;								/*!< DMA外设地址递增 */
	dma_init_struct.priority = DMA_PRIORITY_HIGH;								/*!< DMA优先级 */
	dma_init_struct.loop_mode_enable = FALSE;									/*!< DMA循环模式 */

	dma_init_struct.memory_base_addr = (uint32_t)buff;							/*!< DMA传输数据的基地址 */
	dma_init_struct.peripheral_base_addr = (uint32_t)&(OLED_SPI_ID->dt);		/*!< DMA传输外设的基地址 */
	dma_init_struct.direction = DMA_DIR_MEMORY_TO_PERIPHERAL;					/*!< DMA传输方向 */
	dma_init(OLED_SPI_DMA_TX_CHANNEL, &dma_init_struct);

	/* 配置DMA中断 */
	dma_interrupt_enable(OLED_SPI_DMA_TX_CHANNEL, DMA_FDT_INT, TRUE);			/*!< 使能DMA传输完成中断 */
	nvic_irq_enable(OLED_SPI_DMA_IRQn, 5, 0);

	/* 使能DMA通道 */
	dma_channel_enable(OLED_SPI_DMA_TX_CHANNEL, TRUE);

}

/* oled写一个字节 */
static void oled_wr_byte(u8 dat, u8 cmd)
{
	uint8_t i = 100;
	/* spi驱动 */
	if(cmd) 
	{	
		gpio_bits_set(OLED_SPI_DC_PORT, OLED_SPI_DC_PIN);  // 数据
	}
	else 
	{		
		gpio_bits_reset(OLED_SPI_DC_PORT, OLED_SPI_DC_PIN); // 地址
	}

	/* spi发送一个字节 */
	spi_i2s_data_transmit(OLED_SPI_ID, dat);
	while(spi_i2s_flag_get(OLED_SPI_ID, SPI_I2S_TDBE_FLAG) == RESET);

	/* 增加操作时序 */
	do{__NOP();}while(i--);
	
}

//更新显存到LCD
void oled_refresh_gram(void)
{
	u8 i, n;
	for(i = 0; i < 8; i++) {
		oled_wr_byte (0xb0 + i, OLED_CMD);  //设置页地址（0~7）

		/* ch1116先发高地址 */
		oled_wr_byte (0x02, OLED_CMD);      //设置显示位置—列低地址
		oled_wr_byte (0x10, OLED_CMD);		//设置显示位置—列高地址
		
		for(n = 0; n < 128; n++) {
			oled_wr_byte(oled_gram[n][i], OLED_DATA);
		}
	}

}

//开启OLED显示
static void oled_display_on(void)
{
	oled_wr_byte(0X8D, OLED_CMD);  //SET DCDC命令
	oled_wr_byte(0X14, OLED_CMD);  //DCDC ON
	oled_wr_byte(0XAF, OLED_CMD);  //DISPLAY ON
}

//关闭OLED显示
static void oled_display_off(void)
{
	oled_wr_byte(0X8D, OLED_CMD);  //SET DCDC命令
	oled_wr_byte(0X10, OLED_CMD);  //DCDC OFF
	oled_wr_byte(0XAE, OLED_CMD);  //DISPLAY OFF
}

//清屏函数,清完屏,整个屏幕是黑色的!和没点亮一样!!!
void oled_clear(void)
{
	u8 i, n;
	for(i = 0; i < 8; i++) {
		for(n = 0; n < 128;n++) {
			oled_gram[n][i] = 0x00;
		}
	}
//	oled_refresh_gram();//更新显示
}

//画点
//x:0~127
//y:0~63
//t:1 填充 0,清空
void oled_draw_point(u8 x, u8 y, u8 t)
{
	u8 pos, bx, temp=0;
	if((x > 127) || (y > 63)) {
		return;//超出范围了.
	}
	pos = 7 - y / 8;
	bx = y % 8;
	temp = 1 << (7 - bx);
	if(t) {
		oled_gram[x][pos] |= temp;
	}
	else {
		oled_gram[x][pos] &= ~temp;
	}
}

//读点
//x:0~127
//y:0~63
u8 oled_readPoint(u8 x, u8 y)
{
	u8 pos, bx, temp = 0x00;
	//x = 127-x;
	y = 63 - y;
	pos = y / 8;
	bx = y % 8;
	temp = 1 << bx;
	if(temp & oled_gram[x][pos]){
		return 1;
	}
	else {
		return 0;
	}
}

//x1,y1,x2,y2 填充区域的对角坐标
//确保x1<=x2;y1<=y2 0<=x1<=127 0<=y1<=63
//dot:0,清空;1,填充
void oled_fill(u8 x1, u8 y1, u8 x2, u8 y2, u8 dot)
{
	u8 x, y;
	for(x = x1;x <= x2;x++)
		for(y = y1;y <= y2; y++) {
			oled_draw_point(x, y, dot);
		}
//	oled_refresh_gram();//更新显示
}

//在指定位置显示一个字符,包括部分字符
//x:0~127
//y:0~63
//f_w:字宽
//f_h:字高
//mode:0,反白显示;1,正常显示
void oled_show_char(u8 x, u8 y, u8 chr, u8 f_w, u8 f_h, u8 mode)
{
	u8 temp, t, t1;
	u8 x_post = x, y_post = y;
	u8 csize = (f_h / 8 + ((f_h % 8) ? 1 : 0)) * f_w;//得到自由分辨字符所占的字节数
	chr = chr - ' ';	// 得到偏移后的值
	for(t = 0; t < csize; t++) {
		if((f_w == 6) && (f_h == 8)) {
			temp = asc2_0608[chr][t];	// 调用0608ascii字体
		}
		else if((f_w == 6) && (f_h == 12)) {
			temp = asc2_0612[chr][t];	// 调用0612ascii字体
		}
		else if((f_w == 8) && (f_h == 16)) {
			temp = asc2_0816[chr][t];	// 调用0816ascii字体
		}
		else if((f_w == 12) && (f_h == 24)) {
			temp = asc2_1224[chr][t];	// 调用1224ascii字体
		}
		else {
		    log_err("no font find");
			return; 					// 没有的字库
		}
		for(t1 = 0; t1 < 8; t1++) {
			if(temp & 0x80)
				oled_draw_point(x_post, y_post, mode);
			else
				oled_draw_point(x_post, y_post, !mode);
			temp <<= 1;
			y_post++;
			if((y_post - y) == f_h) {	// 按照实际字符高度填充
				y_post = y;
				x_post++;
				break;
			}
		}
	}
}

//m^n函数
static u32 mypow(u8 m, u8 n)
{
	u32 result = 1;
	while(n--) {
		result *= m;
	}
	return result;
}

//显示2个数字
//x,y :起点坐标
//len :数字的位数
//f_w:字宽
//f_h:字高
//mode:模式	0,填充模式;1,叠加模式
//num:数值(0~4294967295);
//mode:0反显，1正常显示
void oled_show_num(u8 x, u8 y, u32 num, u8 len, u8 f_w, u8 f_h, u8 mode)
{
	u8 t, temp;
	u8 enshow = 0;
	for(t = 0; t < len; t++) {
		temp = (num / mypow(10, len - t - 1)) % 10;
		if((enshow == 0) && (t < (len - 1))) {
			if(temp == 0) {			//指定位数，高位0填充空格
				oled_show_char(x + (f_w) * t, y, ' ', f_w, f_h, mode);
				continue;
			}
			else {
				enshow = 1;
			}
		}
	 	oled_show_char(x + (f_w) * t, y, temp + '0', f_w, f_h, mode);
	}
}

//显示字符串
//x,y:起点坐标
//f_w:字宽
//f_h:字高
//*p:字符串起始地址
void oled_show_string(u8 x, u8 y, const u8 *p, u8 f_w, u8 f_h, u8 mode)
{
	u8 x_post = x, y_post = y;
    while((*p <= '~') && (*p >= ' ')) {	// 判断是不是非法字符!
        if(x_post > (128 - (f_w))) {
        	x_post = 0;
        	y_post += f_h;
        }
        if(y_post > (64 - f_h)) {
        	x_post = y_post = 0;
        	oled_clear();
        }
        oled_show_char(x_post, y_post, *p, f_w, f_h, mode);
        x_post += f_w;
        p++;
    }
}

//显示图片
//x,y:起点坐标
//p_w:图片宽（单位像素）
//p_h:图片高（单位像素）
//*p:图片起始地址
void oled_show_picture(u8 x, u8 y, const u8 *p, u8 p_w, u8 p_h)
{
	u8 temp, i, col, row;
	u8 x_post = x, y_post = y;
	u8 width = p_w;
	u8 exp_col_bytes;
	u8 act_col_bytes;
	u8 high;
	if(x_post + p_w > 128)
		width = 128 - p_w;	// 实际显示宽度
	high = p_h;
	if(y_post + p_h > 64)
		high = 64 - p_h;	// 实际显示高度
	exp_col_bytes = (p_h / 8 + ((p_h % 8) ? 1 : 0));//显示一列的字节数
	act_col_bytes = (high / 8 + ((high % 8) ? 1 : 0));//实际显示一列的字节数

	for(row = 0; row < width; row++) {				//列++
		for(col = 0; col < act_col_bytes; col++) {	//显示一列
			temp = p[col + row * exp_col_bytes];
			for(i = 0; i < 8; i++) {
				if(temp & 0x80)
					oled_draw_point(x_post, y_post, 1);
				else
					oled_draw_point(x_post, y_post, 0);
				temp <<= 1;
				y_post++;
				if((y_post - y) == high) {
					y_post = y;
					x_post++;
					break;
				}
			}
		}
	}
}


//显示一个指定大小的汉字
//x,y :汉字的坐标
//font:汉字GBK码
//f_w:字宽
//f_h:字高
//mode:0,正常显示,1,叠加显示
void show_font(u16 x, u16 y, const u8 *font, u8 f_w, u8 f_h, u8 mode)
{
	const char* font_table;
	u16 fontSeq;
	u8 temp, t, t1;
	u16 x_post = x, y_post = y;
	u8 csize = (f_h / 8 + ((f_h % 8) ? 1 : 0)) * f_w;//得到自由分辨字符所占的字节数

	if((f_w == 16) && (f_h == 16))
		font_table = font_1616_table;
	else
		return;/*没有的字库*/

	for(fontSeq = 0; fontSeq < strlen(font_table) / 2; fontSeq++) {/*计算font_table对应字库的数组下标*/
		if((font_table[2 * fontSeq] == font[0]) && (font_table[2 * fontSeq + 1] == font[1]))
			break;
	}
	
	if(fontSeq >= (strlen(font_table) / 2)) {
		return;/*font_table中没有font该字*/
	}

	for(t = 0; t < csize; t++) {
		if((f_w == 16) && (f_h == 16))
			temp = font_1616[fontSeq][t];/*调用font_1616字库*/
		for(t1 = 0; t1 < 8; t1++) {
			if(temp & 0x80)
				oled_draw_point(x_post, y_post, mode);
			else
				oled_draw_point(x_post, y_post, !mode);
			temp <<= 1;
			y_post++;
			if((y_post - y) == f_h) {
				y_post = y;
				x_post++;
				break;
			}
		}
	}
}

//在指定位置开始显示一个字符串
//支持自动换行
//(x,y):起始坐标
//width,height:区域
//str  :字符串
//f_w:字宽
//f_h:字高
//mode:0,非叠加方式;1,叠加方式
void show_str(u16 x, u16 y, const u8* str, u8 f_w, u8 f_h, u8 mode)
{
	u16 x_post = x;		//起始坐标
	u16 y_post = y;
    u8 bHz = 0;     	//字符或者中文
    while(*str != 0) {	//数据未结束
        if(!bHz) {
	        if(*str > 0x80) {
	        	bHz = 1;	//中文
	        }
	        else {          //字符
                if(x_post > (x + OLCD_WIDTH - f_h / 2)) {	//换行
					y_post += f_h;
					x_post = x;
				}
		        if(y_post > (y + OLCD_HIGH - f_h)) {
		        	break;//越界返回
		        }
		        if(*str == 13) {	//换行符号
		            y_post += f_h;
					x_post = x;
		            str++;
		        }
		        else {
		        	oled_show_char(x_post, y_post, *str, f_w / 2, f_h, mode);	//有效部分写入
		        }
				str++;
		        x_post += f_h / 2; //字符,为全字的一半
	        }
        }
        else {	//中文
            bHz = 0;	//有汉字库
            if(x_post > (x + OLCD_WIDTH - f_h)) {	//换行
				y_post += f_h + 2;	//2为行间距
				x_post = x;
			}
	        if(y_post > (y + OLCD_HIGH - f_h))
	        	break;//越界返回
	        show_font(x_post, y_post, str, f_w, f_h, mode); //显示这个汉字,空心显示
	        str += 2;
	        x_post += f_h;//下一个汉字偏移
        }
    }
}

//在指定宽度的中间显示字符串
//如果字符长度超过了len,则用Show_Str显示
//len:指定要显示的宽度
void show_str_mid(u16 x, u16 y, const u8* str, u8 f_w, u8 f_h, u8 mode, u8 len)
{
	u8 str_len = 0;
   	str_len = strlen((char*)str);
	str_len *= f_h / 2;
	if(str_len > len) {
		show_str(x, y, str, f_w, f_h, mode);
	}
	else {
		str_len = (len - str_len) / 2;
	    show_str(str_len + x, y, str, f_w, f_h, mode);
	}
}


/* 初始化oled */
void bsp_oled_init(void)
{
	/* 初始化oled引脚和spi */
	oled_gpio_config();
	oled_spi_config();

	/* 复位oled */
	OLED_RES_Clr();
	bsp_delay_ms(200);
	OLED_RES_Set();

	oled_wr_byte(0xAE,OLED_CMD); //关闭显示
	
	oled_wr_byte(0xD5,OLED_CMD); //设置时钟分频因子,震荡频率
	oled_wr_byte(0x80,OLED_CMD); //[3:0],分频因子;[7:4],震荡频率
	
	oled_wr_byte(0xA8,OLED_CMD); //设置驱动路数
	oled_wr_byte(0X3F,OLED_CMD); //默认0X3F(1/64)
	
	oled_wr_byte(0xD3,OLED_CMD); //设置显示偏移
	oled_wr_byte(0X00,OLED_CMD); //默认为0

	oled_wr_byte(0x40,OLED_CMD); //设置显示开始行 [5:0],行数.

	oled_wr_byte(0x8D,OLED_CMD); //电荷泵设置
	oled_wr_byte(0x14,OLED_CMD); //bit2，开启/关闭
	oled_wr_byte(0x20,OLED_CMD); //设置内存地址模式
	oled_wr_byte(0x01,OLED_CMD); //[1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10;
	oled_wr_byte(0xA1,OLED_CMD); //段重定义设置,bit0:0,0->0;1,0->127;
	
	oled_wr_byte(0xC0,OLED_CMD); //设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数
//	oled_wr_byte(0xC8,OLED_CMD); //设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数
	
	oled_wr_byte(0xDA,OLED_CMD); //设置COM硬件引脚配置
	oled_wr_byte(0x12,OLED_CMD); //[5:4]配置

	oled_wr_byte(0x81,OLED_CMD); //对比度设置
	oled_wr_byte(0xEF,OLED_CMD); //1~255;默认0X7F (亮度设置,越大越亮)
	
	oled_wr_byte(0xD9,OLED_CMD); //设置预充电周期
	oled_wr_byte(0xf1,OLED_CMD); //[3:0],PHASE 1;[7:4],PHASE 2;
	
	oled_wr_byte(0xDB,OLED_CMD); //设置VCOMH 电压倍率
	oled_wr_byte(0x30,OLED_CMD); //[6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc;

	oled_wr_byte(0xA4,OLED_CMD); //全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏)
	
	oled_wr_byte(0xA6,OLED_CMD); //设置显示方式;bit0:1,反相显示;0,正常显示
	
	oled_wr_byte(0xAF,OLED_CMD); //开启显示


	/* 清屏 */
	oled_clear();			

	oled_refresh_gram();	
	
	DBG_log("oled init");
}

/* 中断服务函数 */
 void OLED_SPI_IRQHandler(void)
{
	if(spi_i2s_flag_get(OLED_SPI_ID, SPI_I2S_RDBF_FLAG) != RESET)
	{
		
	}
}

void OLED_SPI_DMA_IRQHandler(void)
{
	if(dma_flag_get(DMA2_FDT2_FLAG) != RESET)
	{
		dma_flag_clear(DMA2_FDT2_FLAG);
	}

}

